#include "LanzadorPajaritos.h"

using namespace TP::Juego::Arena::Utilidades;

pajaro_t* LanzadorPajaritos::__generarPajaro(struct InfoMov *semillero) {
	pajaro_t* nuevoPajarito;
	double tmp = drand48();
	if (tmp < semillero->_prob_rojo) {
		nuevoPajarito = new PajaritoRojo();
	}
	else if ((tmp >= semillero->_prob_rojo) && (tmp < semillero->_prob_rojo +
			semillero->_prob_azul)) {
		nuevoPajarito = new PajaritoAzul();
	}
	else {
		nuevoPajarito = new PajaritoVerde();
	}
	return nuevoPajarito;
}

Posicion* LanzadorPajaritos::__generarPosicion(
		struct InfoMov *semillero) const {
	TuplaAleatoria posicion(semillero->_pXm, semillero->_pXM, semillero->_pYm,
			semillero->_pYM);
	Posicion *nuevaPosicion;
	pos_t posX, posY;
	posicion.generarNumeros(posX, posY);
	nuevaPosicion = new Posicion(posX, posY);
	return nuevaPosicion;
}

Vector2D* LanzadorPajaritos::__generarVelocidad(
		struct InfoMov *semillero) const {
	Vector2D *nuevaVelocidad;
	speed_t speedX, speedY;
	TuplaAleatoria velocidad(semillero->_vXm, semillero->_vXM, semillero->_vYm,
			semillero->_vYM);
	velocidad.generarNumeros(speedX, speedY);
	nuevaVelocidad = new Vector2D(speedX, speedY);
	return nuevaVelocidad;
}

Vector2D* LanzadorPajaritos::__generarAceleracion(
		struct InfoMov *semillero) const {
	Vector2D *nuevaAceleracion;
	accel_t accelX, accelY;
	TuplaAleatoria aceleracion(semillero->_aXm, semillero->_aXM,
			semillero->_aYm, semillero->_aYM);
	aceleracion.generarNumeros(accelX, accelY);
	nuevaAceleracion = new Vector2D(accelX, accelY);
	return nuevaAceleracion;
}

void LanzadorPajaritos::__disparar(Escenario *pEscenario,
		struct InfoMov *semillero) {
	int cantPajaros; // Cantidad de pájaros que se van a lanzar.
	pajaro_t* nuevoPajaro;
	Posicion *posicion;
	Vector2D *velocidad;
	Vector2D *aceleracion;

	// Cantidad de pájaros que va a tener el grupo a lanzar.
	cantPajaros = (rand() % CANT_MAX_PAJAROS);
	for (int i = 0; i < cantPajaros; ++i) {
		// Genero el pajaro.
		nuevoPajaro = __generarPajaro(semillero);

		// Defino los parametros de la trayectoria.
		posicion = __generarPosicion(semillero);
		velocidad = __generarVelocidad(semillero);
		aceleracion = __generarAceleracion(semillero);

		// Agrego a la arena de juego al actor.
		pEscenario->addActor(nuevoPajaro, posicion, velocidad, aceleracion);
	}
}

LanzadorPajaritos::LanzadorPajaritos() {
	srand(time(NULL)); // Inicializo las semillas para hacer el RANDOM.
	srand48(time(NULL));
	time(&_tiempoActual);
	//this->_tiempoActual = 0;
}

LanzadorPajaritos::~LanzadorPajaritos() { }

bool LanzadorPajaritos::lanzados() {
	return true;
}

void LanzadorPajaritos::disparar(Partida *pPartida) {
	time_t tiempoAux;
	time(&tiempoAux);
	if (difftime(tiempoAux, _tiempoActual) > tiempo_lanzamiento) {
		for (vector<struct InfoMov*>::iterator it = pPartida->ArenaJuego(
				)->getSemillasGeneradorPajaritos().begin();
				it != pPartida->ArenaJuego()->getSemillasGeneradorPajaritos(
				).end(); ++it) {
			__disparar(pPartida->ArenaJuego(), (*it));
		}
		time(&_tiempoActual);
	}
}